package module.StoreService.Impl;

import common.model.Entity.StoreEntity.Order;
import dao.StoreDao.OrderDao;
import dao.impl.StoreDaoImpl.OrderDaoImpl;
import module.StoreService.OrderService;
import network.protocol.Response;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Optional;

/**
 * {@code OrderServiceImpl} 是 {@link OrderService} 的实现类，
 * 提供订单（Order）的增删改查、状态更新以及统计等功能。
 * <p>
 * 主要功能：
 * <ul>
 *     <li>根据 ID 或订单号获取订单</li>
 *     <li>获取用户订单、状态订单或全部订单</li>
 *     <li>创建、更新、删除订单</li>
 *     <li>更新订单状态</li>
 *     <li>统计订单总数、用户订单数量</li>
 * </ul>
 * <p>
 * 实现逻辑通过 {@link OrderDao} 与数据库交互，
 * 并使用 {@link Response} 封装统一的返回结果。
 * <p>
 * 类采用单例模式，请通过 {@link #getInstance()} 获取实例。
 */
public class OrderServiceImpl implements OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
    private final OrderDao orderDao = new OrderDaoImpl();
    private static final OrderServiceImpl INSTANCE = new OrderServiceImpl();

    /**
     * 私有构造函数，防止外部直接实例化。
     */
    private OrderServiceImpl() {}

    /**
     * 获取 {@code OrderServiceImpl} 的单例对象。
     *
     * @return 单例实例
     */
    public static OrderServiceImpl getInstance() {
        return INSTANCE;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Optional<Order>> getOrderById(long id) {
        try {
            Optional<Order> order = orderDao.findById(id);
            return Response.success(order);
        } catch (Exception e) {
            logger.error("获取订单失败: id={}", id, e);
            return Response.error("获取订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Optional<Order>> getOrderByNumber(String orderNumber) {
        try {
            Optional<Order> order = orderDao.findByOrderNumber(orderNumber);
            return Response.success(order);
        } catch (Exception e) {
            logger.error("获取订单失败: orderNumber={}", orderNumber, e);
            return Response.error("获取订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<List<Order>> getOrdersByUser(long userId) {
        try {
            List<Order> orders = orderDao.findByUser(userId);
            return Response.success(orders);
        } catch (Exception e) {
            logger.error("获取用户订单失败: userId={}", userId, e);
            return Response.error("获取用户订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<List<Order>> getOrdersByStatus(int status) {
        try {
            if (status < 0 || status > 2) {
                logger.warn("获取订单失败: 状态值 {} 无效，必须是0(未支付)、1(已支付)或2(已取消)", status);
                return Response.error("状态值无效，必须是0(未支付)、1(已支付)或2(已取消)");
            }
            List<Order> orders = orderDao.findByStatus(status);
            return Response.success(orders);
        } catch (Exception e) {
            logger.error("获取状态订单失败: status={}", status, e);
            return Response.error("获取状态订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<List<Order>> getOrdersByUserAndStatus(long userId, int status) {
        try {
            if (status < 0 || status > 2) {
                logger.warn("获取订单失败: 状态值 {} 无效，必须是0(未支付)、1(已支付)或2(已取消)", status);
                return Response.error("状态值无效，必须是0(未支付)、1(已支付)或2(已取消)");
            }
            List<Order> orders = orderDao.findByUserAndStatus(userId, status);
            return Response.success(orders);
        } catch (Exception e) {
            logger.error("获取用户状态订单失败: userId={}, status={}", userId, status, e);
            return Response.error("获取用户状态订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<List<Order>> getAllOrders() {
        try {
            List<Order> orders = orderDao.findAll();
            return Response.success(orders);
        } catch (Exception e) {
            logger.error("获取所有订单失败", e);
            return Response.error("获取所有订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Boolean> createOrder(Order order) {
        try {
            // 验证订单数据
            if (order.getUserId() <= 0) {
                logger.warn("创建订单失败: 用户ID无效");
                return Response.error("用户ID无效");
            }
            if (order.getOrderNumber() == null || order.getOrderNumber().trim().isEmpty()) {
                logger.warn("创建订单失败: 订单号不能为空");
                return Response.error("订单号不能为空");
            }
            if (order.getTotalAmount() < 0) {
                logger.warn("创建订单失败: 订单总金额不能为负数");
                return Response.error("订单总金额不能为负数");
            }
            if (order.getStatus() < 0 || order.getStatus() > 2) {
                logger.warn("创建订单失败: 状态值无效");
                return Response.error("状态值无效，必须是0(未支付)、1(已支付)或2(已取消)");
            }

            // 检查订单号是否已存在
            Optional<Order> existingOrder = orderDao.findByOrderNumber(order.getOrderNumber());
            if (existingOrder.isPresent()) {
                logger.warn("创建订单失败: 订单号 {} 已存在", order.getOrderNumber());
                return Response.error("订单号已存在");
            }

            boolean result = orderDao.save(order);
            return result ? Response.success(true) : Response.error("创建订单失败");
        } catch (Exception e) {
            logger.error("创建订单失败: orderNumber={}", order.getOrderNumber(), e);
            return Response.error("创建订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Boolean> updateOrder(Order order) {
        try {
            if (orderDao.findById(order.getId()).isEmpty()) {
                logger.warn("更新订单失败: 未找到ID为 {} 的订单", order.getId());
                return Response.error("未找到指定订单");
            }
            if (order.getTotalAmount() < 0) {
                logger.warn("更新订单失败: 订单总金额不能为负数");
                return Response.error("订单总金额不能为负数");
            }
            if (order.getStatus() < 0 || order.getStatus() > 2) {
                logger.warn("更新订单失败: 状态值无效");
                return Response.error("状态值无效，必须是0(未支付)、1(已支付)或2(已取消)");
            }

            boolean result = orderDao.update(order);
            return result ? Response.success(true) : Response.error("更新订单失败");
        } catch (Exception e) {
            logger.error("更新订单失败: id={}", order.getId(), e);
            return Response.error("更新订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Boolean> deleteOrder(long id) {
        try {
            if (orderDao.findById(id).isEmpty()) {
                logger.warn("删除订单失败: 未找到ID为 {} 的订单", id);
                return Response.error("未找到指定订单");
            }

            boolean result = orderDao.deleteById(id);
            return result ? Response.success(true) : Response.error("删除订单失败");
        } catch (Exception e) {
            logger.error("删除订单失败: id={}", id, e);
            return Response.error("删除订单失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Boolean> updateOrderStatus(long orderId, int status) {
        try {
            if (status < 0 || status > 2) {
                logger.warn("更新订单状态失败: 状态值 {} 无效，必须是0(未支付)、1(已支付)或2(已取消)", status);
                return Response.error("状态值无效，必须是0(未支付)、1(已支付)或2(已取消)");
            }
            Optional<Order> orderOpt = orderDao.findById(orderId);
            if (orderOpt.isEmpty()) {
                logger.warn("更新订单状态失败: 未找到ID为 {} 的订单", orderId);
                return Response.error("未找到指定订单");
            }

            Order order = orderOpt.get();
            order.setStatus(status);
            boolean result = orderDao.update(order);
            return result ? Response.success(true) : Response.error("更新订单状态失败");
        } catch (Exception e) {
            logger.error("更新订单状态失败: orderId={}, status={}", orderId, status, e);
            return Response.error("更新订单状态失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Long> getOrderCount() {
        try {
            long count = orderDao.count();
            return Response.success(count);
        } catch (Exception e) {
            logger.error("获取订单总数失败", e);
            return Response.error("获取订单总数失败: " + e.getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Response<Long> getOrderCountByUser(long userId) {
        try {
            List<Order> userOrders = orderDao.findByUser(userId);
            long count = userOrders.size();
            return Response.success(count);
        } catch (Exception e) {
            logger.error("获取用户订单总数失败: userId={}", userId, e);
            return Response.error("获取用户订单总数失败: " + e.getMessage());
        }
    }
}
